package com.moxi.mogublog.config.jwt;

import com.moxi.mogublog.config.security.SecurityUser;
import com.moxi.mogublog.utils.Base64Util;
import io.jsonwebtoken.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import java.security.Key;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * JWT工具类
 *
 * @author JackLi
 * @date 2020/6/1 18:18
 */
@Component
public class JwtTokenUtil {

    private static final Logger log = LoggerFactory.getLogger(JwtTokenUtil.class);

    /**
     * 解析jwt
     *
     * @param jsonWebToken
     * @param base64Security
     * @return
     */
    public static Claims parseJWT(String jsonWebToken, String base64Security) {
        try {
            Claims claims = Jwts.parser()
                    // 设置签名的秘钥
                    .setSigningKey(DatatypeConverter.parseBase64Binary(base64Security))
                    // 设置需要解析的jwt
                    .parseClaimsJws(jsonWebToken).getBody();
            return claims;
        } catch (ExpiredJwtException eje) {
            log.error("===== Token过期 =====", eje);
            return null;
        } catch (Exception e) {
            log.error("===== token解析异常 =====", e);
            return null;
        }
    }


    /**
     * 构建jwt
     *
     * @param userId   账户id
     * @param username 账户名
     * @param role     账户拥有角色名
     * @param audience 代表这个Jwt的接受对象
     * @return
     */
    public static String createJWT(String userId,
                                   String username,
                                   String role,
                                   Audience audience) {


        /*

        tokenProperties.getAudience().getClientId(),
                tokenProperties.getAudience().getName(),
                expiresSecond * 1000,
                tokenProperties.getAudience().getBase64Secret()

         */
        try {
            // 指定签名的时候使用的签名算法(使用HS256加密算法)，也就是 header 部分，jjwt 已经将这部分内容封装好
            SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

            // 生成JWT的时间
            long nowMillis = System.currentTimeMillis();
            Date now = new Date(nowMillis);

            //生成签名密钥
            byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(audience.getBase64Secret());
            Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());

            //userId是重要信息，进行加密下
            String encryId = Base64Util.encode(userId);

            // 创建payload的私有声明（根据特定的业务需要添加，如果要拿这个做验证，一般是需要和jwt的接收方提前沟通好验证方式的）
            Map<String, Object> claims = new HashMap<>(3);
            claims.put("adminUid", userId);
            claims.put("role", role);
            claims.put("creatTime", now);

            /**
             * 添加构成JWT的参数
             */
            // 这里其实就是new一个JwtBuilder，设置jwt的body
            JwtBuilder builder = Jwts.builder()
                    .setHeaderParam("typ", "JWT")
                    // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
                    .setClaims(claims)
                    // sub(Subject)：代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可以存放什么userid，roldid之类的，作为什么用户的唯一标志。
                    .setSubject(username)
                    // iat: 是一个时间戳，代表这个JWT的签发时间
                    .setIssuedAt(now)
                    // issuer：JWT的签发主体
                    .setIssuer(audience.getClientId())
                    // JWT的接收对象
                    .setAudience(audience.getName())
                    // 签名:设置签名使用的签名算法和签名使用的秘钥
                    .signWith(signatureAlgorithm, signingKey);

            // 设置 token 过期时间
            int TTLMillis = audience.getExpiresSecond() * 1000;
            if (TTLMillis >= 0) {
                long expMillis = nowMillis + TTLMillis;
                Date exp = new Date(expMillis);
                builder
                        // 是一个时间戳，代表这个JWT的过期时间；
                        .setExpiration(exp)
                        // 是一个时间戳，代表这个JWT生效的开始时间，意味着在这个时间之前验证JWT是会失败的
                        .setNotBefore(now);
            }
            //生成JWT
            return builder.compact();
        } catch (Exception e) {
            log.error("签名失败", e);
            return null;
//            throw new CustomException(ResultCode.PERMISSION_SIGNATURE_ERROR);
        }
    }

    /**
     * 校验 token
     *
     * @param token
     * @param userDetails
     * @param base64Security
     * @return
     */
    public static Boolean validateToken(String token, UserDetails userDetails, String base64Security) {
        SecurityUser SecurityUser = (SecurityUser) userDetails;
        final String username = getUsername(token, base64Security);
        final boolean expiration = isExpiration(token, base64Security);
        return (username.equals(SecurityUser.getUsername()) && !expiration);
    }

    /**
     * 从token中获取用户名
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static String getUsername(String token, String base64Security) {
        return parseJWT(token, base64Security).getSubject();
    }

    /**
     * 从token中获取用户ID
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static String getUserId(String token, String base64Security) {
        String userId = parseJWT(token, base64Security).get("adminUid", String.class);
//        return Base64Util.decode(userId);
        return userId;
    }


    /**
     * 判断token是否已过期
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static boolean isExpiration(String token, String base64Security) {
        if (parseJWT(token, base64Security) == null) {
            return true;
        } else {
            return parseJWT(token, base64Security).getExpiration().before(new Date());
        }
    }

    /**
     * 从token中获取audience
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static String getAudience(String token, String base64Security) {
        return parseJWT(token, base64Security).getAudience();
    }

    /**
     * 从token中获取issuer
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static String getIssuer(String token, String base64Security) {
        return parseJWT(token, base64Security).getIssuer();
    }

    /**
     * 从token中获取Expiration
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static Date getExpiration(String token, String base64Security) {
        return parseJWT(token, base64Security).getExpiration();
    }

    /**
     * token 是否可以更新
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static Boolean canTokenBeRefreshed(String token, String base64Security) {
        return !isExpiration(token, base64Security);
    }

    /**
     * 更新 token
     *
     * @param token
     * @param base64Security
     * @param TTLMillis
     * @return
     */
    public static String refreshToken(String token, String base64Security, long TTLMillis) {
        String refreshedToken;
        try {
            SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
            long nowMillis = System.currentTimeMillis();
            Date now = new Date(nowMillis);
            // 生成签名密钥
            byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(base64Security);
            Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());

            final Claims claims = parseJWT(token, base64Security);
            claims.put("creatDate", new Date());
            JwtBuilder builder = Jwts.builder().setHeaderParam("typ", "JWT")
                    .setClaims(claims)
                    .setSubject(getUsername(token, base64Security))
                    .setIssuer(getIssuer(token, base64Security))
                    .setAudience(getAudience(token, base64Security))
                    // 签名
                    .signWith(signatureAlgorithm, signingKey);
            // 添加Token过期时间
            if (TTLMillis >= 0) {
                long expMillis = nowMillis + TTLMillis;
                Date exp = new Date(expMillis);
                builder.setExpiration(exp).setNotBefore(now);
            }
            refreshedToken = builder.compact();
        } catch (Exception e) {
            refreshedToken = null;
        }
        return refreshedToken;
    }

}
